// hook/useSmartForm.js
import { ref, reactive, onMounted } from 'vue'
import DeviceDetector from '@/util/ai-recommend/deviceDetector'
import { ElMessage } from 'element-plus'
import request from '@/util/request'

/**
 * 智能表单Hook
 */
export function useSmartForm() {
    // 设备信息
    const deviceInfo = ref(null)
    const deviceScore = ref(null)

    // 智能推荐状态
    const smartRecommendation = reactive({
        loading: false,
        enabled: true,
        data: null,
        error: null,
        applied: false // 新增：标记是否已应用推荐配置
    })

    // 简化的默认配置（AI推荐未启用时使用）
    const simpleFormConfig = {
        faceOptions: [
            {
                value: 50000,
                label: '5万面',
                desc: '快速预览'
            },
            {
                value: 150000,
                label: '15万面',
                desc: '标准质量'
            },
            {
                value: 300000,
                label: '30万面',
                desc: '高质量'
            }
        ],
        generateTypeOptions: [
            {
                value: 'Normal',
                name: '标准模型',
                desc: '生成标准的3D模型，适合大部分场景'
            },
            {
                value: 'LowPoly',
                name: '低多边形',
                desc: '生成面数较少的模型，适合游戏和实时渲染'
            },
            {
                value: 'Geometry',
                name: '纯几何',
                desc: '只生成几何结构，不包含材质贴图'
            }
        ],
        taskVersionRecommendation: {
            recommended: null,
            reason: null
        },
        enablePBRRecommendation: {
            recommended: null,
            reason: null
        }
    }

    // 完整的默认配置（容错使用，包含推荐标签和理由）
    const fullFormConfig = {
        faceOptions: [
            {
                value: 50000,
                label: '5万面',
                desc: '快速预览',
                tag: '快速',
                tagType: 'info',
                reason: '适合设备性能一般的用户，生成速度快'
            },
            {
                value: 150000,
                label: '15万面',
                desc: '标准质量',
                tag: '推荐',
                tagType: 'success',
                reason: '平衡质量与性能的最佳选择'
            },
            {
                value: 300000,
                label: '30万面',
                desc: '高质量',
                tag: '高质',
                tagType: 'warning',
                reason: '需要较好的设备性能，适合质量要求较高的场景'
            }
        ],
        generateTypeOptions: [
            {
                value: 'Normal',
                name: '标准模型',
                desc: '生成标准的3D模型，适合大部分场景',
                tag: '推荐',
                tagType: 'success',
                reason: '标准选择，适合大部分用户需求'
            },
            {
                value: 'LowPoly',
                name: '低多边形',
                desc: '生成面数较少的模型，适合游戏和实时渲染',
                tag: '性能优先',
                tagType: 'info',
                reason: '适合性能受限的设备或需要实时渲染的场景'
            },
            {
                value: 'Geometry',
                name: '纯几何',
                desc: '只生成几何结构，不包含材质贴图',
                tag: '轻量',
                tagType: 'info',
                reason: '最轻量的选择，适合网络条件较差的用户'
            }
        ],
        taskVersionRecommendation: {
            recommended: 'rapid',
            reason: '基于当前网络环境，推荐使用快速版以获得更好的体验'
        },
        enablePBRRecommendation: {
            recommended: false,
            reason: '考虑到当前设备性能，建议关闭PBR材质以提升生成速度'
        }
    }

    // 当前表单配置（初始使用简化版）
    const formConfig = ref({ ...simpleFormConfig })

    /**
     * 初始化设备检测
     */
    const initDeviceDetection = async () => {
        try {
            console.log('开始检测设备信息...')
            const info = await DeviceDetector.getDeviceInfo()
            deviceInfo.value = info
            deviceScore.value = DeviceDetector.getDeviceScore(info)

            console.log('设备信息:', info)
            console.log('设备评分:', deviceScore.value)

            return info
        } catch (error) {
            console.error('设备检测失败:', error)
            ElMessage.warning('设备检测失败，将使用默认推荐配置')
            return null
        }
    }

    /**
     * 获取智能推荐
     */
    const getSmartRecommendation = async (userPrompt = '') => {
        if (!smartRecommendation.enabled) {
            return formConfig.value
        }

        smartRecommendation.loading = true
        smartRecommendation.error = null
        smartRecommendation.applied = false

        try {
            // 确保有设备信息
            if (!deviceInfo.value) {
                await initDeviceDetection()
            }

            const requestData = {
                deviceInfo: deviceInfo.value,
                deviceScore: deviceScore.value,
                userPrompt: userPrompt.trim(),
                currentTime: new Date().toISOString()
            }

            console.log('发送智能推荐请求:', requestData)

            const response = await request.post('/backcode/api/smart-form/recommend', requestData, {
                showLoading: false
            })

            if (response.success) {
                // 只存储推荐数据，不立即更新表单配置
                smartRecommendation.data = response.data
                console.log('智能推荐数据获取成功:', response.data)
                ElMessage.success('AI智能推荐已完成，点击更新按钮应用配置')
            } else {
                throw new Error(response.message || '获取推荐失败')
            }

        } catch (error) {
            console.error('智能推荐失败:', error)
            smartRecommendation.error = error.message

            // 容错处理：使用基于设备评分的简单推荐
            const fallbackConfig = generateFallbackRecommendation()
            smartRecommendation.data = fallbackConfig

            ElMessage.warning('AI推荐暂时不可用，已启用基础智能推荐')
        } finally {
            smartRecommendation.loading = false
        }

        return formConfig.value
    }

    /**
     * 应用智能推荐配置
     */
    const applySmartRecommendation = () => {
        if (!smartRecommendation.data) {
            ElMessage.warning('没有可应用的推荐配置')
            return false
        }

        try {
            // 合并AI推荐配置（修复：使用 fullFormConfig 而不是 defaultFormConfig）
            formConfig.value = {
                ...fullFormConfig,
                ...smartRecommendation.data
            }

            smartRecommendation.applied = true
            console.log('智能推荐配置已应用:', formConfig.value)
            ElMessage.success('已应用AI智能推荐配置')
            return true
        } catch (error) {
            console.error('应用推荐配置失败:', error)
            ElMessage.error('应用推荐配置失败')
            return false
        }
    }

    /**
     * 生成容错推荐配置
     */
    const generateFallbackRecommendation = () => {
        // 修复：使用 fullFormConfig 而不是 defaultFormConfig
        const config = { ...fullFormConfig }

        if (!deviceScore.value) {
            return config
        }

        const { level, totalScore } = deviceScore.value

        // 基于设备性能调整推荐
        if (level === 'high') {
            // 高性能设备推荐
            config.faceOptions = config.faceOptions.map(option => {
                if (option.value === 300000) {
                    return {
                        ...option,
                        tag: 'AI推荐',
                        tagType: 'success',
                        reason: '您的设备性能优秀，推荐使用高质量模型获得最佳效果'
                    }
                }
                return option
            })

            config.taskVersionRecommendation = {
                recommended: 'pro',
                reason: '您的设备性能优秀，推荐使用专业版获得更多功能和更好效果'
            }

            config.enablePBRRecommendation = {
                recommended: true,
                reason: '您的设备支持PBR材质，建议启用以获得更逼真的效果'
            }

        } else if (level === 'low') {
            // 低性能设备推荐
            config.faceOptions = config.faceOptions.map(option => {
                if (option.value === 50000) {
                    return {
                        ...option,
                        tag: 'AI推荐',
                        tagType: 'success',
                        reason: '基于您的设备性能，推荐使用快速模式以获得更流畅的体验'
                    }
                }
                return option
            })

            config.generateTypeOptions = config.generateTypeOptions.map(option => {
                if (option.value === 'LowPoly') {
                    return {
                        ...option,
                        tag: 'AI推荐',
                        tagType: 'success',
                        reason: '针对您的设备优化，低多边形模型具有更好的性能表现'
                    }
                }
                return option
            })

            config.taskVersionRecommendation = {
                recommended: 'rapid',
                reason: '基于您的设备性能，推荐使用快速版以获得更流畅的体验'
            }
        }

        return config
    }

    /**
     * 重置为默认配置
     */
    const resetToDefaultConfig = () => {
        // 根据智能推荐开关状态选择配置版本
        formConfig.value = smartRecommendation.enabled
            ? { ...fullFormConfig }
            : { ...simpleFormConfig }

        smartRecommendation.applied = false
        console.log('已重置为默认配置')
        ElMessage.info('已重置为默认配置')
    }

    /**
     * 设置智能推荐开关
     */
    const setSmartRecommendationEnabled = (enabled) => {
        smartRecommendation.enabled = enabled
        smartRecommendation.applied = false

        if (enabled) {
            // 启用智能推荐时，切换到完整配置版本
            formConfig.value = { ...fullFormConfig }
            console.log('智能推荐已启用，切换到完整配置版本')
        } else {
            // 关闭智能推荐时，切换到简化配置版本
            formConfig.value = { ...simpleFormConfig }
            console.log('智能推荐已关闭，切换到简化配置版本')
        }
    }

    /**
     * 重新获取推荐
     */
    const refreshRecommendation = async (userPrompt = '') => {
        return await getSmartRecommendation(userPrompt)
    }

    /**
     * 获取设备信息摘要
     */
    const getDeviceSummary = () => {
        if (!deviceInfo.value || !deviceScore.value) {
            return '设备信息检测中...'
        }

        const { level, totalScore } = deviceScore.value
        const { deviceType, cpu, network } = deviceInfo.value

        const summaryParts = []

        summaryParts.push(`${deviceType?.type || '未知设备'}`)

        if (cpu?.cores) {
            summaryParts.push(`${cpu.cores}核CPU`)
        }

        if (network?.effectiveType) {
            summaryParts.push(`${network.effectiveType.toUpperCase()}网络`)
        }

        summaryParts.push(`性能评级: ${level.toUpperCase()}`)

        return summaryParts.join(' | ')
    }

    // 组件挂载时初始化
    onMounted(async () => {
        await initDeviceDetection()
    })

    return {
        // 状态
        deviceInfo,
        deviceScore,
        smartRecommendation,
        formConfig,

        // 方法
        initDeviceDetection,
        getSmartRecommendation,
        applySmartRecommendation,
        resetToDefaultConfig,
        setSmartRecommendationEnabled,
        refreshRecommendation,
        getDeviceSummary,

        // 配置版本
        simpleFormConfig,  // 简化版配置
        fullFormConfig     // 完整版配置
    }
}